﻿using System;
using System.ComponentModel;

namespace HalconDotNet
{
	/// <summary>Represents an instance of a 3D graphic scene.</summary>
	// Token: 0x0200005E RID: 94
	public class HScene3D : HHandle
	{
		// Token: 0x06001749 RID: 5961 RVA: 0x00095A8C File Offset: 0x00093C8C
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HScene3D(IntPtr handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x0600174A RID: 5962 RVA: 0x00095A9B File Offset: 0x00093C9B
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HScene3D(HHandle handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x0600174B RID: 5963 RVA: 0x00095AAA File Offset: 0x00093CAA
		private void AssertSemType()
		{
			base.AssertSemType("scene_3d");
		}

		// Token: 0x0600174C RID: 5964 RVA: 0x00095AB7 File Offset: 0x00093CB7
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HScene3D obj)
		{
			obj = new HScene3D(HHandleBase.UNDEF);
			return obj.Load(proc, parIndex, err);
		}

		// Token: 0x0600174D RID: 5965 RVA: 0x00095AD0 File Offset: 0x00093CD0
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HScene3D[] obj)
		{
			HTuple htuple;
			err = HTuple.LoadNew(proc, parIndex, err, out htuple);
			obj = new HScene3D[htuple.Length];
			for (int i = 0; i < htuple.Length; i++)
			{
				obj[i] = new HScene3D(HalconAPI.IsLegacyHandleMode() ? htuple[i].IP : htuple[i].H);
			}
			htuple.Dispose();
			return err;
		}

		/// <summary>
		///   Create the data structure that is needed to visualize collections of 3D objects.
		///   Modified instance represents: Handle of the 3D scene.
		/// </summary>
		// Token: 0x0600174E RID: 5966 RVA: 0x00095B40 File Offset: 0x00093D40
		public HScene3D()
		{
			IntPtr proc = HalconAPI.PreCall(1220);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Get the depth or the index of instances in a displayed 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="row">Row coordinates.</param>
		/// <param name="column">Column coordinates.</param>
		/// <param name="information">Information. Default: "depth"</param>
		/// <returns>Indices or the depth of the objects at (Row,Column).</returns>
		// Token: 0x0600174F RID: 5967 RVA: 0x00095B84 File Offset: 0x00093D84
		public HTuple GetDisplayScene3dInfo(HWindow windowHandle, HTuple row, HTuple column, HTuple information)
		{
			IntPtr proc = HalconAPI.PreCall(1204);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.Store(proc, 2, row);
			HalconAPI.Store(proc, 3, column);
			HalconAPI.Store(proc, 4, information);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(information);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
			return result;
		}

		/// <summary>
		///   Get the depth or the index of instances in a displayed 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="row">Row coordinates.</param>
		/// <param name="column">Column coordinates.</param>
		/// <param name="information">Information. Default: "depth"</param>
		/// <returns>Indices or the depth of the objects at (Row,Column).</returns>
		// Token: 0x06001750 RID: 5968 RVA: 0x00095C08 File Offset: 0x00093E08
		public int GetDisplayScene3dInfo(HWindow windowHandle, double row, double column, string information)
		{
			IntPtr proc = HalconAPI.PreCall(1204);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.StoreD(proc, 2, row);
			HalconAPI.StoreD(proc, 3, column);
			HalconAPI.StoreS(proc, 4, information);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
			return result;
		}

		/// <summary>
		///   Set the pose of a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="toWorldPose">New pose of the 3D scene.</param>
		// Token: 0x06001751 RID: 5969 RVA: 0x00095C78 File Offset: 0x00093E78
		public void SetScene3dToWorldPose(HPose toWorldPose)
		{
			IntPtr proc = HalconAPI.PreCall(1205);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, toWorldPose);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(toWorldPose);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set parameters of a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="genParamName">Names of the generic parameters. Default: "quality"</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: "high"</param>
		// Token: 0x06001752 RID: 5970 RVA: 0x00095CC4 File Offset: 0x00093EC4
		public void SetScene3dParam(string genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1206);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.Store(proc, 2, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set parameters of a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="genParamName">Names of the generic parameters. Default: "quality"</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: "high"</param>
		// Token: 0x06001753 RID: 5971 RVA: 0x00095D10 File Offset: 0x00093F10
		public void SetScene3dParam(string genParamName, string genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1206);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.StoreS(proc, 2, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set parameters of a light in a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="lightIndex">Index of the light source.</param>
		/// <param name="genParamName">Names of the generic parameters. Default: "ambient"</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: [0.2,0.2,0.2]</param>
		// Token: 0x06001754 RID: 5972 RVA: 0x00095D54 File Offset: 0x00093F54
		public void SetScene3dLightParam(int lightIndex, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1207);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, lightIndex);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set parameters of a light in a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="lightIndex">Index of the light source.</param>
		/// <param name="genParamName">Names of the generic parameters. Default: "ambient"</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: [0.2,0.2,0.2]</param>
		// Token: 0x06001755 RID: 5973 RVA: 0x00095DAC File Offset: 0x00093FAC
		public void SetScene3dLightParam(int lightIndex, string genParamName, string genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1207);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, lightIndex);
			HalconAPI.StoreS(proc, 2, genParamName);
			HalconAPI.StoreS(proc, 3, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set the pose of an instance in a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="instanceIndex">Index of the instance.</param>
		/// <param name="pose">New pose of the instance.</param>
		// Token: 0x06001756 RID: 5974 RVA: 0x00095DF8 File Offset: 0x00093FF8
		public void SetScene3dInstancePose(HTuple instanceIndex, HPose[] pose)
		{
			HTuple htuple = HData.ConcatArray(pose);
			IntPtr proc = HalconAPI.PreCall(1208);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, instanceIndex);
			HalconAPI.Store(proc, 2, htuple);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(instanceIndex);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set the pose of an instance in a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="instanceIndex">Index of the instance.</param>
		/// <param name="pose">New pose of the instance.</param>
		// Token: 0x06001757 RID: 5975 RVA: 0x00095E54 File Offset: 0x00094054
		public void SetScene3dInstancePose(int instanceIndex, HPose pose)
		{
			IntPtr proc = HalconAPI.PreCall(1208);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, instanceIndex);
			HalconAPI.Store(proc, 2, pose);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(pose);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set parameters of an instance in a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="instanceIndex">Index of the instance.</param>
		/// <param name="genParamName">Names of the generic parameters. Default: "color"</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: "green"</param>
		// Token: 0x06001758 RID: 5976 RVA: 0x00095EA8 File Offset: 0x000940A8
		public void SetScene3dInstanceParam(HTuple instanceIndex, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1209);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, instanceIndex);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(instanceIndex);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set parameters of an instance in a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="instanceIndex">Index of the instance.</param>
		/// <param name="genParamName">Names of the generic parameters. Default: "color"</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: "green"</param>
		// Token: 0x06001759 RID: 5977 RVA: 0x00095F08 File Offset: 0x00094108
		public void SetScene3dInstanceParam(int instanceIndex, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1209);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, instanceIndex);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set the pose of a camera in a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="cameraIndex">Index of the camera.</param>
		/// <param name="pose">New pose of the camera.</param>
		// Token: 0x0600175A RID: 5978 RVA: 0x00095F60 File Offset: 0x00094160
		public void SetScene3dCameraPose(int cameraIndex, HPose pose)
		{
			IntPtr proc = HalconAPI.PreCall(1210);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, cameraIndex);
			HalconAPI.Store(proc, 2, pose);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(pose);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Render an image of a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="cameraIndex">Index of the camera used to display the scene.</param>
		/// <returns>Rendered 3D scene.</returns>
		// Token: 0x0600175B RID: 5979 RVA: 0x00095FB4 File Offset: 0x000941B4
		public HImage RenderScene3d(int cameraIndex)
		{
			IntPtr proc = HalconAPI.PreCall(1211);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, cameraIndex);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Remove a light from a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="lightIndex">Light to remove.</param>
		// Token: 0x0600175C RID: 5980 RVA: 0x00096004 File Offset: 0x00094204
		public void RemoveScene3dLight(int lightIndex)
		{
			IntPtr proc = HalconAPI.PreCall(1212);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, lightIndex);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Remove an object instance from a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="instanceIndex">Index of the instance to remove.</param>
		// Token: 0x0600175D RID: 5981 RVA: 0x00096040 File Offset: 0x00094240
		public void RemoveScene3dInstance(HTuple instanceIndex)
		{
			IntPtr proc = HalconAPI.PreCall(1213);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, instanceIndex);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(instanceIndex);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Remove an object instance from a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="instanceIndex">Index of the instance to remove.</param>
		// Token: 0x0600175E RID: 5982 RVA: 0x00096084 File Offset: 0x00094284
		public void RemoveScene3dInstance(int instanceIndex)
		{
			IntPtr proc = HalconAPI.PreCall(1213);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, instanceIndex);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Remove a camera from a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="cameraIndex">Index of the camera to remove.</param>
		// Token: 0x0600175F RID: 5983 RVA: 0x000960C0 File Offset: 0x000942C0
		public void RemoveScene3dCamera(int cameraIndex)
		{
			IntPtr proc = HalconAPI.PreCall(1214);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, cameraIndex);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Display a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="cameraIndex">Index of the camera used to display the scene.</param>
		// Token: 0x06001760 RID: 5984 RVA: 0x000960FC File Offset: 0x000942FC
		public void DisplayScene3d(HWindow windowHandle, HTuple cameraIndex)
		{
			IntPtr proc = HalconAPI.PreCall(1215);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.Store(proc, 2, cameraIndex);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(cameraIndex);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Display a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="cameraIndex">Index of the camera used to display the scene.</param>
		// Token: 0x06001761 RID: 5985 RVA: 0x0009614C File Offset: 0x0009434C
		public void DisplayScene3d(HWindow windowHandle, string cameraIndex)
		{
			IntPtr proc = HalconAPI.PreCall(1215);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.StoreS(proc, 2, cameraIndex);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Add a light source to a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="lightPosition">Position of the new light source. Default: [-100.0,-100.0,0.0]</param>
		/// <param name="lightKind">Type of the new light source. Default: "point_light"</param>
		/// <returns>Index of the new light source in the 3D scene.</returns>
		// Token: 0x06001762 RID: 5986 RVA: 0x00096198 File Offset: 0x00094398
		public int AddScene3dLight(HTuple lightPosition, string lightKind)
		{
			IntPtr proc = HalconAPI.PreCall(1216);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, lightPosition);
			HalconAPI.StoreS(proc, 2, lightKind);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(lightPosition);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add an instance of a 3D object model to a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="objectModel3D">Handle of the 3D object model.</param>
		/// <param name="pose">Pose of the 3D object model.</param>
		/// <returns>Index of the new instance in the 3D scene.</returns>
		// Token: 0x06001763 RID: 5987 RVA: 0x000961F8 File Offset: 0x000943F8
		public int AddScene3dInstance(HObjectModel3D[] objectModel3D, HPose[] pose)
		{
			HTuple htuple = HHandleBase.ConcatArray(objectModel3D);
			HTuple htuple2 = HData.ConcatArray(pose);
			IntPtr proc = HalconAPI.PreCall(1217);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, htuple);
			HalconAPI.Store(proc, 2, htuple2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(htuple2);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Add an instance of a 3D object model to a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="objectModel3D">Handle of the 3D object model.</param>
		/// <param name="pose">Pose of the 3D object model.</param>
		/// <returns>Index of the new instance in the 3D scene.</returns>
		// Token: 0x06001764 RID: 5988 RVA: 0x0009627C File Offset: 0x0009447C
		public int AddScene3dInstance(HObjectModel3D objectModel3D, HPose pose)
		{
			IntPtr proc = HalconAPI.PreCall(1217);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, objectModel3D);
			HalconAPI.Store(proc, 2, pose);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(pose);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectModel3D);
			return result;
		}

		/// <summary>
		///   Add a camera to a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="cameraParam">Parameters of the new camera.</param>
		/// <returns>Index of the new camera in the 3D scene.</returns>
		// Token: 0x06001765 RID: 5989 RVA: 0x000962EC File Offset: 0x000944EC
		public int AddScene3dCamera(HCamPar cameraParam)
		{
			IntPtr proc = HalconAPI.PreCall(1218);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, cameraParam);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(cameraParam);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Delete a 3D scene and free all allocated memory.</summary>
		/// <param name="scene3D">Handle of the 3D scene.</param>
		// Token: 0x06001766 RID: 5990 RVA: 0x0009634C File Offset: 0x0009454C
		public static void ClearScene3d(HScene3D[] scene3D)
		{
			HTuple htuple = HHandleBase.ConcatArray(scene3D);
			IntPtr proc = HalconAPI.PreCall(1219);
			HalconAPI.Store(proc, 0, htuple);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(scene3D);
		}

		/// <summary>
		///   Delete a 3D scene and free all allocated memory.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		// Token: 0x06001767 RID: 5991 RVA: 0x00096390 File Offset: 0x00094590
		public void ClearScene3d()
		{
			IntPtr proc = HalconAPI.PreCall(1219);
			base.Store(proc, 0);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create the data structure that is needed to visualize collections of 3D objects.
		///   Modified instance represents: Handle of the 3D scene.
		/// </summary>
		// Token: 0x06001768 RID: 5992 RVA: 0x000963C4 File Offset: 0x000945C4
		public void CreateScene3d()
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1220);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Add a text label to a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="text">Text of the label. Default: "label"</param>
		/// <param name="referencePoint">Point of reference of the label.</param>
		/// <param name="position">Position of the label. Default: "top"</param>
		/// <param name="relatesTo">Indicates fixed or relative positioning. Default: "point"</param>
		/// <returns>Index of the new label in the 3D scene.</returns>
		// Token: 0x06001769 RID: 5993 RVA: 0x00096408 File Offset: 0x00094608
		public int AddScene3dLabel(HTuple text, HTuple referencePoint, HTuple position, HTuple relatesTo)
		{
			IntPtr proc = HalconAPI.PreCall(2040);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, text);
			HalconAPI.Store(proc, 2, referencePoint);
			HalconAPI.Store(proc, 3, position);
			HalconAPI.Store(proc, 4, relatesTo);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(text);
			HalconAPI.UnpinTuple(referencePoint);
			HalconAPI.UnpinTuple(position);
			HalconAPI.UnpinTuple(relatesTo);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a text label to a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="text">Text of the label. Default: "label"</param>
		/// <param name="referencePoint">Point of reference of the label.</param>
		/// <param name="position">Position of the label. Default: "top"</param>
		/// <param name="relatesTo">Indicates fixed or relative positioning. Default: "point"</param>
		/// <returns>Index of the new label in the 3D scene.</returns>
		// Token: 0x0600176A RID: 5994 RVA: 0x0009648C File Offset: 0x0009468C
		public int AddScene3dLabel(string text, HTuple referencePoint, HTuple position, HTuple relatesTo)
		{
			IntPtr proc = HalconAPI.PreCall(2040);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, text);
			HalconAPI.Store(proc, 2, referencePoint);
			HalconAPI.Store(proc, 3, position);
			HalconAPI.Store(proc, 4, relatesTo);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(referencePoint);
			HalconAPI.UnpinTuple(position);
			HalconAPI.UnpinTuple(relatesTo);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Remove a text label from a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="labelIndex">Index of the text label to remove.</param>
		// Token: 0x0600176B RID: 5995 RVA: 0x00096508 File Offset: 0x00094708
		public void RemoveScene3dLabel(HTuple labelIndex)
		{
			IntPtr proc = HalconAPI.PreCall(2041);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, labelIndex);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(labelIndex);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Remove a text label from a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="labelIndex">Index of the text label to remove.</param>
		// Token: 0x0600176C RID: 5996 RVA: 0x0009654C File Offset: 0x0009474C
		public void RemoveScene3dLabel(int labelIndex)
		{
			IntPtr proc = HalconAPI.PreCall(2041);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, labelIndex);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set parameters of a text label in a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="labelIndex">Index of the text label.</param>
		/// <param name="genParamName">Names of the generic parameters. Default: "color"</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: "red"</param>
		// Token: 0x0600176D RID: 5997 RVA: 0x00096588 File Offset: 0x00094788
		public void SetScene3dLabelParam(HTuple labelIndex, string genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(2042);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, labelIndex);
			HalconAPI.StoreS(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(labelIndex);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set parameters of a text label in a 3D scene.
		///   Instance represents: Handle of the 3D scene.
		/// </summary>
		/// <param name="labelIndex">Index of the text label.</param>
		/// <param name="genParamName">Names of the generic parameters. Default: "color"</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: "red"</param>
		// Token: 0x0600176E RID: 5998 RVA: 0x000965E0 File Offset: 0x000947E0
		public void SetScene3dLabelParam(int labelIndex, string genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(2042);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, labelIndex);
			HalconAPI.StoreS(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}
	}
}
